package com.mz.ozy.utils;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Build;
import android.os.Environment;
import android.telephony.TelephonyManager;
import android.text.Editable;
import android.text.TextUtils;
import android.util.Base64;
import android.util.TypedValue;
import android.view.View;
import android.view.WindowManager;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.ImageView;

import com.luck.picture.lib.entity.LocalMedia;

import org.jetbrains.annotations.NotNull;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.net.NetworkInterface;
import java.net.URLDecoder;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 */
public class Utils {

    public static int getNavigationBarHeight(Context context) {
        if (checkDeviceHasNavigationBar(context)) {
            Resources resources = context.getResources();
            int resourceId = resources.getIdentifier("navigation_bar_height", "dimen", "android");
            int height = resources.getDimensionPixelSize(resourceId);
            return height;
        } else {
            return 0;
        }
    }

    public static String long2DateStr(Long timeInt) {
        final int h = Utils.generateH(timeInt);
        final int m = Utils.generateM(timeInt);
        final int s = Utils.generateS(timeInt);
        return formatHMS(h, m, s);
    }

    public static String formatHMS(int h, int m, int s) {
        String timestr = "";
        if (h >= 10) {
            timestr = timestr + h;
            timestr = timestr + ":";
        } else {
            if (h > 0) {
                timestr = timestr + "0" + h;
                timestr = timestr + ":";
            }
        }
        if (m >= 10) {
            timestr = timestr + m;
        } else {
            timestr = timestr + "0" + m;
        }
        timestr = timestr + ":";
        if (s >= 10) {
            timestr = timestr + s;
        } else {
            timestr = timestr + "0" + s;
        }
        return timestr;
    }

    public static String formatHMS(long h, long m, long s) {
        String timestr = "";
        if (h >= 10) {
            timestr = timestr + h;
            timestr = timestr + ":";
        } else {
            if (h > 0) {
                timestr = timestr + "0" + h;
                timestr = timestr + ":";
            }
        }
        if (m >= 10) {
            timestr = timestr + m;
        } else {
            timestr = timestr + "0" + m;
        }
        timestr = timestr + ":";
        if (s >= 10) {
            timestr = timestr + s;
        } else {
            timestr = timestr + "0" + s;
        }
        return timestr;
    }

    public static boolean checkDeviceHasNavigationBar(Context context) {
        boolean hasNavigationBar = false;
        Resources rs = context.getResources();
        int id = rs.getIdentifier("config_showNavigationBar", "bool", "android");
        if (id > 0) {
            hasNavigationBar = rs.getBoolean(id);
        }
        try {
            Class systemPropertiesClass = Class.forName("android.os.SystemProperties");
            Method m = systemPropertiesClass.getMethod("get", String.class);
            String navBarOverride = (String) m.invoke(systemPropertiesClass, "qemu.hw.mainkeys");
            if ("1".equals(navBarOverride)) {
                hasNavigationBar = false;
            } else if ("0".equals(navBarOverride)) {
                hasNavigationBar = true;
            }
        } catch (Exception e) {
            //do something
        }
        return hasNavigationBar;
    }

    /**
     * 将html文本内容中包含img标签的图片，宽度变为屏幕宽度，高度根据宽度比例自适应
     **/
    public static String getNewContent(String htmltext) {
        try {
            Document doc = Jsoup.parse(htmltext);
            Elements elements = doc.getElementsByTag("img");
            for (Element element : elements) {
                element.attr("width", "100%").attr("height", "auto");
            }

            return doc.toString();
        } catch (Exception e) {
            return htmltext;
        }
    }

    /**
     * * 两个Double数相除 *
     *
     * @param v1 *
     * @param v2 *
     * @return Double
     */
    public static int div(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1 + "");
        BigDecimal b2 = new BigDecimal(v2 + "");
        return (int) b1.divide(b2, 1, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    public static <T> boolean notEmpty(List<T> list) {
        return !isEmpty(list);
    }

    public static <T> boolean isEmpty(List<T> list) {
        if (list == null || list.size() == 0) {
            return true;
        }
        return false;
    }


    //网络是否可用
    public boolean isNetworkConnected(Context context) {
        if (context != null) {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
            if (mNetworkInfo != null) {
                return mNetworkInfo.isAvailable();
            }
        }
        return false;
    }

    public static String getDecodeStr(String str) {
        String returnStr = null;
        try {
            returnStr = URLDecoder.decode(str, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            returnStr = str;
        }
        return returnStr;
    }

    public static void playPraiseAnim(ImageView imageView) {
//        imageView.setImageResource(R.drawable.praise_anim);
//        AnimationDrawable animationDrawable = (AnimationDrawable) imageView.getDrawable();
//        //animationDrawable.setOneShot(true);
//        animationDrawable.start();
    }

    public static void playUnPraiseAnim(ImageView imageView) {
//        imageView.setImageResource(R.drawable.praise_reverse_anim);
//        AnimationDrawable animationDrawable = (AnimationDrawable) imageView.getDrawable();
//        //animationDrawable.setOneShot(true);
//        animationDrawable.start();
    }

    public static boolean isEmpty(String src) {
        return src == null || src.trim().length() == 0;
    }

    public static int dp2px(Context context, int dip) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dip * scale + 0.5f);
    }

    public static int sp2px(Context context, float spValue) {
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, spValue, context.getResources().getDisplayMetrics());
    }

    // 将px值转换为dip或dp值
    public static int px2dip(Context context, float pxValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (pxValue / scale + 0.5f);
    }

    public static String getDate(Date date) {//可根据需要自行截取数据显示
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日");
        return format.format(date);
    }

    public static String formatDateStr(String datestr) {//可根据需要自行截取数据显示
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            SimpleDateFormat formatOut = new SimpleDateFormat("MM月dd日");
            final Date parseDate = format.parse(datestr);
            return formatOut.format(parseDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return "";
    }

    public static String getDateFormat(Date date) {//可根据需要自行截取数据显示
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        return format.format(date);
    }

    public static String getTime(Date date) {//可根据需要自行截取数据显示
        SimpleDateFormat format = new SimpleDateFormat("HH:mm");
        return format.format(date);
    }

    //获取时间   ---毫秒
    public static Long getLongTime(String time) {//可根据需要自行截取数据显示
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date date = format.parse(time);
            return date.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return 0L;
    }


    // 将px值转换为sp值
    public static int px2sp(Context context, float pxValue) {
        final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
        return (int) (pxValue / fontScale + 0.5f);
    }

    public static String getDate(long time) {//可根据需要自行截取数据显示

        SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
        String s = format.format(time * 1000);
        return s;
    }

    public static String getHhMm(long time) {//可根据需要自行截取数据显示
        SimpleDateFormat format = new SimpleDateFormat("HH:mm");
        String s = format.format(time);
        return s;
    }

    /**
     * 获取设备ID
     */
//    @SuppressLint("MissingPermission")
//    public static String obtainDeviceId(Context context) {
//        TelephonyManager telephonyManager = (TelephonyManager) context
//                .getSystemService(Context.TELEPHONY_SERVICE);
//        return MD5Util.getMD5String(telephonyManager.getDeviceId() + getMacAddr());
//    }

    /**
     * 获取版本号
     *
     * @return 当前应用的版本号
     */
    public static String getVersion(Context context) {
        try {
            PackageManager manager = context.getPackageManager();
            PackageInfo info = manager.getPackageInfo(context.getPackageName(), 0);
            return info.versionName;
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

//    public static String getMacAddr() {
//        try {
//            List<NetworkInterface> all = Collections.list(NetworkInterface.getNetworkInterfaces());
//            for (NetworkInterface nif : all) {
//                if (!nif.getName().equalsIgnoreCase("wlan0")) continue;
//
//                byte[] macBytes = nif.getHardwareAddress();
//                if (macBytes == null) {
//                    return "";
//                }
//
//                StringBuilder res1 = new StringBuilder();
//                for (byte b : macBytes) {
//                    res1.append(String.format("%02X:", b));
//                }
//
//                if (res1.length() > 0) {
//                    res1.deleteCharAt(res1.length() - 1);
//                }
//                return res1.toString();
//            }
//        } catch (Exception ex) {
//        }
//        return "02:00:00:00:00:00";
//    }

    /**
     * 获取版本号
     *
     * @return 当前应用的版本号
     */
    public static int getVersionCode(Context context) {
        try {
            PackageManager manager = context.getPackageManager();
            PackageInfo info = manager.getPackageInfo(context.getPackageName(), 0);
            return info.versionCode;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取七日时间
     *
     * @return
     */
    public static List<String> getDate() {
        List<String> dateList = new ArrayList<>();
        SimpleDateFormat format = new SimpleDateFormat("MM-dd");
        //过去七天

        for (int i = 10; i > 0; i--) {
            Calendar c = Calendar.getInstance();
            c.setTime(new Date());
            c.add(Calendar.DATE, -i);
            Date d = c.getTime();
            String day = format.format(d);
            dateList.add(day);
        }
        return dateList;
    }

    public static String bitmapToBase64(Bitmap bitmap) {

        String result = null;
        ByteArrayOutputStream baos = null;
        try {
            if (bitmap != null) {
                baos = new ByteArrayOutputStream();
                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);

                baos.flush();
                baos.close();

                byte[] bitmapBytes = baos.toByteArray();
                result = Base64.encodeToString(bitmapBytes, Base64.DEFAULT);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.flush();
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 判断是否有SD卡
     *
     * @return true为有SDcard，false则表示没有
     */
    public static boolean hasSdcard() {
        boolean hasCard = false;
        String state = Environment.getExternalStorageState();
        if (state.equals(Environment.MEDIA_MOUNTED)) {
            hasCard = true;
        }
        return hasCard;
    }


    /**
     * 正则表达式:验证身份证
     */
    public static final String REGEX_ID_CARD = "(\\d{17}[0-9a-zA-Z])";

    /**
     * 校验身份证
     *
     * @param idCard
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isIDCard(String idCard) {
        return Pattern.matches(REGEX_ID_CARD, idCard);

    }

    public static boolean isAppInstalled(Context context, String packageName) {
        final PackageManager packageManager = context.getPackageManager();
        List<PackageInfo> pinfo = packageManager.getInstalledPackages(0);
        List<String> pName = new ArrayList<String>();
        if (pinfo != null) {
            for (int i = 0; i < pinfo.size(); i++) {
                String pn = pinfo.get(i).packageName;
                pName.add(pn);
            }
        }
        return pName.contains(packageName);
    }

    /**
     * 年月日转换
     * 20171120 -> 11-20
     *
     * @param str
     * @return
     */
    public static String formatMonthDay(String str) {
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
        String result = "";
        try {
            Date date = format.parse(str);
            format = new SimpleDateFormat("dd");
            result = format.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return result;
    }

    public static String formatMonth(String str) {
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
        String result = "";
        try {
            Date date = format.parse(str);
            format = new SimpleDateFormat("MM");
            result = format.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return result;
    }

    /* *
     * 验证手机格式
     */
    public static boolean isMobile(String number) {
        /**
         移动：134、135、136、137、138、139、150、151、152、157(TD)、158、159、178(新)、182、184、187、188
         联通：130、131、132、152、155、156、185、186
         电信：133、153、170、173、177、180、181、189、（1349卫通）
         总结起来就是第一位必定为1，第二位必定为3或5或8，其他位置的可以为0-9
         */
        String num = "[1][3456789]\\d{9}";//"[1]"代表第1位为数字1，"[34578]"代表第二位可以为3、4、5、7、8中的一个，"\\d{9}"代表后面是可以是0～9的数字，有9位。
        if (TextUtils.isEmpty(number)) {
            return false;
        } else {
            //matches():字符串是否在给定的正则表达式匹配
            return number.matches(num);
        }
    }

    public static String getSystemLanguage(Context context) {
        Locale locale;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            locale = context.getResources().getConfiguration().getLocales().get(0);
        } else {
            locale = context.getResources().getConfiguration().locale;
        }
        return locale.getLanguage() + "_" + locale.getCountry();
    }

    /**
     * 强制隐藏软键盘
     */
    public static void hideSoft(Context context, View view) {
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        //imm.showSoftInput(view, InputMethodManager.SHOW_FORCED); //强制显示键盘
        imm.hideSoftInputFromWindow(view.getWindowToken(), 0); //强制隐藏键盘


    }

    public static void hideSoft(Activity activity) {
        InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputMethodManager.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS);
    }

    /**
     * EditText获取焦点并显示软键盘
     */
    public static void showSoftInputFromWindow(Activity activity, EditText editText) {
        editText.setFocusable(true);
        editText.setFocusableInTouchMode(true);
        editText.requestFocus();
        activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

    }


    //判断email格式是否正确
    public static boolean isEmail(String email) {
        String str = "^([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([a-zA-Z0-9\\-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$";
        Pattern p = Pattern.compile(str);
        Matcher m = p.matcher(email);
        return m.matches();
    }

    //判断是否全是数字
    public static boolean isNumeric(String str) {
        Pattern pattern = Pattern.compile("[0-9]*");
        Matcher isNum = pattern.matcher(str);
        if (!isNum.matches()) {
            return false;
        }
        return true;
    }

    //判断是否包含英文和数字组合
    public static boolean ispsd(String psd) {
        Pattern p = Pattern
                .compile("^[a-zA-Z].*[0-9]|.*[0-9].*[a-zA-Z]");
        Matcher m = p.matcher(psd);

        return m.matches();
    }

    /**
     * 使用java正则表达式去掉多余的.与0
     *
     * @param num
     * @return
     */
    public static String subFourNumber(double num) {
        DecimalFormat format = new DecimalFormat("0.0000");//构造方法的字符格式这里如果小数不足2位,会以0补足.
        return format.format(num);//format 返回的是字符串
    }

    /**
     * 使用java正则表达式去掉多余的.与0
     *
     * @param num
     * @return
     */
    public static String subSixNumber(double num) {
        DecimalFormat format = new DecimalFormat("0.000000");//构造方法的字符格式这里如果小数不足2位,会以0补足.
        return format.format(num);//format 返回的是字符串
    }

    /**
     * 使用java正则表达式去掉多余的.与0
     *
     * @param num
     * @return
     */
    public static String subTwoNumber(double num) {
        DecimalFormat format = new DecimalFormat("0.00");//构造方法的字符格式这里如果小数不足2位,会以0补足.
        return format.format(num);//format 返回的是字符串
    }

    //判断是否包含大小写英文和数字组合
    public static boolean isPwdFormat(String psd) {

        Pattern p = Pattern
                .compile("^(?![0-9A-Z]+$)(?![0-9a-z]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{8,20}$$");
        Matcher m = p.matcher(psd);
        return m.matches();
    }

    //判断是否包含大小写英文和数字组合
    public static boolean isAddress(String address) {

        Pattern p = Pattern
                .compile("^(0x)?[0-9a-fA-F]{40}$");
        Matcher m = p.matcher(address);
        return m.matches();
    }


    //判断是否包含中文
    public static boolean isContainChinese(String str) {


        Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
        Matcher m = p.matcher(str);
        if (m.find()) {
            return true;
        }
        return false;

    }

    /**
     * 使用java正则表达式去掉多余的.与0
     *
     * @param s
     * @return
     */
    public static String subZeroAndDot(String s) {
        if (s.indexOf(".") > 0) {
            s = s.replaceAll("0+?$", "");//去掉多余的0
            s = s.replaceAll("[.]$", "");//如最后一位是.则去掉
        }
        return s;
    }

    public static double setNumberFormat(double s, int value) {

        BigDecimal bg = new BigDecimal(s);
        double f = bg.setScale(value, BigDecimal.ROUND_HALF_UP).doubleValue();
        return f;
    }

    public static boolean editTextUtils(Editable editable, EditText editText) {
        String s = editable.toString();
        //这部分是处理如果输入框内小数点后已有两位，那么舍弃最后一位赋值，光标移动到最后
        int index = editText.getSelectionStart();//获取光标位置

        if (s.toString().contains(".")) {
            if (s.length() - s.toString().indexOf(".") > 5) {
                editable.delete(s.toString().length() - 1, s.length());
                editText.setSelection(s.toString().trim().length() - 1);

                return false;
            }
            if (s.substring(0, s.toString().indexOf(".")).length() >= 7) {
                editable.delete(index - 1, index);
                return false;
            }
        } else {
            if (s.length() >= 7) {
                editable.delete(s.length() - 1, s.length());
                return false;
            }
        }

        //这部分是处理如果用户输入以.开头，在前面加上0
        if (s.toString().trim().substring(0).equals(".")) {
            editText.setText("0" + s);
            editText.setSelection(2);
            return false;
        }
        //这里处理用户 多次输入.的处理 比如输入 1..6的形式，是不可以的
        if (s.toString().startsWith("0") && s.toString().trim().length() > 1) {
            if (!s.toString().substring(1, 2).equals(".")) {
                editText.setText(s.subSequence(0, 1));
                editText.setSelection(1);
                return false;
            }
        }


        return true;
    }

    public static void handleEditTextUtils(Editable editable, EditText editText) {
        String s = editable.toString();
        //这部分是处理如果输入框内小数点后已有两位，那么舍弃最后一位赋值，光标移动到最后
        int index = editText.getSelectionStart();//获取光标位置

        if (s.toString().contains(".")) {
            if (s.length() - s.toString().indexOf(".") > 3) {
                editable.delete(s.toString().length() - 1, s.length());
                editText.setSelection(s.toString().trim().length() - 1);

                return;
            }
            if (s.substring(0, s.toString().indexOf(".")).length() >= 20) {
                editable.delete(index - 1, index);
                return;
            }
        } else {
            if (s.length() >= 20) {
                editable.delete(s.length() - 1, s.length());
                return;
            }
        }

        //这部分是处理如果用户输入以.开头，在前面加上0
        if (s.toString().trim().substring(0).equals(".")) {
            editText.setText("0" + s);
            editText.setSelection(2);
            return;
        }
        //这里处理用户 多次输入.的处理 比如输入 1..6的形式，是不可以的
        if (s.toString().startsWith("0") && s.toString().trim().length() > 1) {
            if (!s.toString().substring(1, 2).equals(".")) {
                editText.setText(s.subSequence(0, 1));
                editText.setSelection(1);
                return;
            }
        }
    }

    public static void editTextUtils(Editable editable, EditText editText, int bit) {
        String s = editable.toString();
        //这部分是处理如果输入框内小数点后已有两位，那么舍弃最后一位赋值，光标移动到最后
        int index = editText.getSelectionStart();//获取光标位置

        if (s.toString().contains(".")) {
            if (s.length() - s.toString().indexOf(".") > bit) {
                editable.delete(s.toString().length() - 1, s.length());
                editText.setSelection(s.toString().trim().length() - 1);
            }
            if (s.substring(0, s.toString().indexOf(".")).length() >= 10) {
                editable.delete(index - 1, index);
            }
        } else {
            if (s.length() >= 10) {
                editable.delete(s.length() - 1, s.length());

            }
        }

        //这部分是处理如果用户输入以.开头，在前面加上0
        if (s.toString().trim().substring(0).equals(".")) {
            editText.setText("0" + s);
            editText.setSelection(2);
        }
        //这里处理用户 多次输入.的处理 比如输入 1..6的形式，是不可以的
        if (s.toString().startsWith("0") && s.toString().trim().length() > 1) {
            if (!s.toString().substring(1, 2).equals(".")) {
                editText.setText(s.subSequence(0, 1));
                editText.setSelection(1);
                return;
            }
        }
    }


    /**
     * 计算距离
     *
     * @param m
     * @return
     */
    public static String getDistance(String m) {
        String s = "";
        if (!TextUtils.isEmpty(m)) {
            if (Double.parseDouble(m) >= 1000) {
                s = new BigDecimal(Double.parseDouble(m) / 1000).setScale(1, BigDecimal.ROUND_HALF_UP).toPlainString() + "km";
            } else {
                s = new BigDecimal(m).setScale(0, BigDecimal.ROUND_HALF_UP).toPlainString() + "m";
            }
        } else {
            s = 0 + "m";
        }
        return s;

    }

    /**
     * 统一保留四位小数点
     *
     * @return
     */
    public static String decimalUtils(String srcNum) {
        if (srcNum != null && !"".equals(srcNum)) {
            return new BigDecimal(srcNum)
                    .setScale(4, BigDecimal.ROUND_HALF_UP)  //保留4位小数，且四舍五入
                    .stripTrailingZeros()    //去除末尾多余的0
                    .toPlainString();   //避免科学计数法，替换 toString()
        } else {
            return "";
        }
    }

    public static String decimalUtils(String srcNum, int decimal) {

        if (srcNum != null && !"".equals(srcNum)) {
            return new BigDecimal(srcNum)
                    .setScale(decimal, BigDecimal.ROUND_HALF_UP)  //保留4位小数，且四舍五入
                    .stripTrailingZeros()    //去除末尾多余的0
                    .toPlainString();   //避免科学计数法，替换 toString()
        } else {
            return "";
        }
//        return new BigDecimal(value).setScale(scale, BigDecimal.ROUND_HALF_UP).toPlainString();
    }


    /**
     * 将秒转时分秒
     *
     * @param time
     * @return
     */
    public static String generateTime(int time) {
        int totalSeconds = time / 1000;
        int seconds = totalSeconds % 60;
        int minutes = (totalSeconds / 60) % 60;
        int hours = totalSeconds / 3600;

        return String.format("%02d:%02d:%02d", hours, minutes, seconds);
    }


    public static String interceptTime(String time) {
        if (time.contains(".")) {
            int indexOf = time.lastIndexOf(".");
            return time.substring(0, indexOf);
        } else {
            return time;
        }
    }

    public static int generateS(long time) {
        long totalSeconds = time;
        int seconds = (int) (totalSeconds % 60);
        return seconds;
    }

    public static int generateM(long time) {
        long totalSeconds = time;
        int minutes = (int) ((totalSeconds / 60) % 60);
        return minutes;
    }

    public static int generateH(long time) {
        long totalSeconds = time;
        int hours = (int) (totalSeconds / 3600);
        return hours;
    }

    public static long getCurDateIntTime() {
        Date date = new Date();
        return date.getTime();
    }

    /**
     * 与当前日期相差多少天
     * 当前日期-指定日期  >0则是在过去   <0则是在未来
     *
     * @return
     */
    public static boolean compareTimeStr(String date1, String date2) {
        try {
            DateFormat df = new SimpleDateFormat("HH:mm");
            //当前时间戳 -> HH:mm:ss，再进行日期对比
            Date d1 = df.parse(date1);
            Date d2 = df.parse(date2);
            return d1.getTime() >= d2.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 格式化日期上午/下午
     *
     * @return
     */
    public static String formatTimeStr(String date1) {
        Date dateObj = null;
        try {
            DateFormat df = new SimpleDateFormat("HH:mm");
            //当前时间戳 -> HH:mm:ss，再进行日期对比
            dateObj = df.parse(date1);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        String timeFormatStr = "";
        if (dateObj != null) {
            timeFormatStr = new SimpleDateFormat("ahh:mm").format(dateObj);
        }
        return timeFormatStr;
    }

    /**
     * 格式化日期上午/下午
     *
     * @return
     */
    public static String formatTimeScopeStr(String timeSp) {
        final String[] timeSpArr = timeSp.split("-");
        final String endTime = Utils.formatTimeStr(timeSpArr[1]).substring(2);
        return Utils.formatTimeStr(timeSpArr[0]) + "-" + endTime;
    }

    /**
     * 与当前日期相差多少天
     * 当前日期-指定日期  >0则是在过去   <0则是在未来
     *
     * @return
     */
    public static boolean compareDateStr(Date date, Date date2) {
        return date.getTime() > date2.getTime();
    }

    /**
     * 与当前日期相差多少天
     * 当前日期-指定日期  >0则是在过去   <0则是在未来
     *
     * @return
     */
    public static boolean equalDateStr(String date1, String date2) {
        try {
            DateFormat df = new SimpleDateFormat("HH:mm");
            //当前时间戳 -> HH:mm:ss，再进行日期对比
            Date d1 = df.parse(date1);
            Date d2 = df.parse(date2);
            return d1.getTime() == d2.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return false;
    }

    public static long parseDateIntTime(String datestr) throws ParseException {//可根据需要自行截取数据显示
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = format.parse(datestr);
        return date.getTime();
    }


    public static List<String> convertToImageList(List<LocalMedia> images) {
        List<String> list = new ArrayList<>();
        for (LocalMedia media : images) {
            String path = "";
            if (media.isCut() && !media.isCompressed()) {
                // 裁剪过
                path = media.getCutPath();
            } else if (media.isCompressed() || (media.isCut() && media.isCompressed())) {
                // 压缩过,或者裁剪同时压缩过,以最终压缩过图片为准
                path = media.getCompressPath();
            } else {
                // 原图
                path = media.getPath();
            }
            if (!TextUtils.isEmpty(path)) {
                list.add(path);
            }
        }
        return list;
    }
}
